<?php

class WfFlujo {
//<editor-fold defaultstate="collapsed" desc="Constantes">
  const NOMBRE_ENTIDAD = "WfFlujo";
  const ARRAY_PASO_LISTADO = 0;
  const ARRAY_PASO_APROBADORES = 1;
  const ARRAY_PASO_PERMISOS = 2;
  const ARRAY_PASO_ENCARGADOS = 3;
  const ARRAY_PASO_ENCARGADOS_PERMISOS = 4;
  //colores
  const COLOR_VERDE = "verde";
  const COLOR_AMARILLO = "amarillo";
  const COLOR_ROJO = "rojo";

//</editor-fold>

//<editor-fold defaultstate="collapsed" desc="Campos">
  private $_id;
  private $_nombre;
  private $_fechaCreacion;
  private $_porcentajeAprobacion;
  private $_idEmpresa;
  private $_idWorkflow;
  private $_idUsuarioCreacion;
  private $_idFlujoEstado;
  private $_idCache;
  private $_esPadre;
  private $_idFlujoPadre;
  private $_eliminado;
  private $_existe;
//</editor-fold>

//<editor-fold defaultstate="collapsed" desc="Propiedades">
  public function getId() { return $this->_id; }
  public function setId($value) { $this->_id = $value; }

  public function getNombre() { return $this->_nombre; }
  public function setNombre($value) { $this->_nombre = $value; }

  public function getFechaCreacion() { return $this->_fechaCreacion; }
  public function setFechaCreacion($value) { $this->_fechaCreacion = $value; }

  public function getPorcentajeAprobacion() { return $this->_porcentajeAprobacion; }
  public function setPorcentajeAprobacion($value) { $this->_porcentajeAprobacion = $value; }

  public function getIdEmpresa() { return $this->_idEmpresa; }
  public function setIdEmpresa($value) { $this->_idEmpresa = $value; }

  public function getIdWorkflow() { return $this->_idWorkflow; }
  public function setIdWorkflow($value) { $this->_idWorkflow = $value; }

  public function getIdUsuarioCreacion() { return $this->_idUsuarioCreacion; }
  public function setIdUsuarioCreacion($value) { $this->_idUsuarioCreacion = $value; }

  public function getIdFlujoEstado() { return $this->_idFlujoEstado; }
  public function setIdFlujoEstado($value) { $this->_idFlujoEstado = $value; }

  public function getIdCache() { return $this->_idCache; }
  public function setIdCache($value) { $this->_idCache = $value; }

  public function getEsPadre() { return $this->_esPadre; }
  public function setEsPadre($value) { $this->_esPadre = $value; }

  public function getIdFlujoPadre() { return $this->_idFlujoPadre; }
  public function setIdFlujoPadre($value) { $this->_idFlujoPadre = $value; }

  public function getEliminado() { return $this->_eliminado; }
  public function setEliminado($value) { $this->_eliminado = $value; }

  public function getExiste() { return $this->_existe; }
  public function setExiste($value) { $this->_existe = $value; }
//</editor-fold>

//<editor-fold defaultstate="collapsed" desc="Metodos Publicos">
  /**
   * constructor
   * @author VSR, 07/12/2011
   */
  public function __construct() {
    try {
      $this->_id = -1;
      $this->_nombre = "";
      $this->_fechaCreacion = "";
      $this->_porcentajeAprobacion = 0;
      $this->_idEmpresa = -1;
      $this->_idWorkflow = -1;
      $this->_idUsuarioCreacion = -1;
      $this->_idFlujoEstado = -1;
        $this->_idCache = -1;
        $this->_esPadre = 0;
        $this->_idFlujoPadre = -1;
        $this->_eliminado = 0;
      $this->_existe = 0;
    } catch (Exception $e) {
      throw new Exception($e->getMessage());
    }
  }

  /**
   * obtiene registro por su id
   * @author VSR, 07/12/2011
   */
  public function obtenerPorId($id = -1) {
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfFlujo_ObtenerPorId({id});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{id}", $id, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
      $totalRegistros = count($arr);

      //si se encontraron registros entonces se asignan
      if ($totalRegistros > 0) {
        $row = $arr[0];
        $this->_id = ( is_null($row["Id"]) ) ? -1 : $row["Id"];
        $this->_nombre = ( is_null($row["Nombre"]) ) ? "" : $row["Nombre"];
        $this->_fechaCreacion = ( is_null($row["FechaCreacion"]) ) ? "" : $row["FechaCreacion"];
        $this->_porcentajeAprobacion = ( is_null($row["PorcentajeAprobacion"]) ) ? 0 : $row["PorcentajeAprobacion"];
        $this->_idEmpresa = ( is_null($row["IdEmpresa"]) ) ? -1 : $row["IdEmpresa"];
        $this->_idWorkflow = ( is_null($row["IdWorkflow"]) ) ? -1 : $row["IdWorkflow"];
        $this->_idUsuarioCreacion = ( is_null($row["IdUsuarioCreacion"]) ) ? -1 : $row["IdUsuarioCreacion"];
        $this->_idFlujoEstado = ( is_null($row["IdFlujoEstado"]) ) ? -1 : $row["IdFlujoEstado"];
        $this->_idCache = ( is_null($row["IdCache"]) ) ? -1 : $row["IdCache"];
        $this->_esPadre = ( is_null($row["EsPadre"]) ) ? 0 : $row["EsPadre"];
        $this->_idFlujoPadre = ( is_null($row["IdFlujoPadre"]) ) ? -1 : $row["IdFlujoPadre"];
        $this->_eliminado = ( is_null($row["Eliminado"]) ) ? 0 : $row["Eliminado"];
        $this->_existe = ($this->_id == -1) ? 0 : 1;
      } else {
        $this->_id = -1;
        $this->_nombre = "";
        $this->_fechaCreacion = "";
        $this->_porcentajeAprobacion = 0;
        $this->_idEmpresa = -1;
        $this->_idWorkflow = -1;
        $this->_idUsuarioCreacion = -1;
        $this->_idFlujoEstado = -1;
        $this->_idCache = -1;
        $this->_esPadre = 0;
        $this->_idFlujoPadre = -1;
        $this->_eliminado = 0;
        $this->_existe = 0;
      }
    } catch (Exception $e) {
      throw new Exception($e->getMessage());
    }
  }

  /**
   * crea o actualiza un registro
   * @author VSR, 07/12/2011
   */
  public function grabar() {
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfFlujo_Grabar({id},'{nombre}','{fechaCreacion}',{porcentajeAprobacion},{idEmpresa},{idWorkflow},{idUsuarioCreacion},{idFlujoEstado},{idCache},{esPadre},{idFlujoPadre},{eliminado});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{id}", $this->_id, $sp);
      $sp = str_replace("{nombre}", $this->_nombre, $sp);
      $sp = str_replace("{fechaCreacion}", $this->_fechaCreacion, $sp);
      $sp = str_replace("{porcentajeAprobacion}", $this->_porcentajeAprobacion, $sp);
      $sp = str_replace("{idEmpresa}", $this->_idEmpresa, $sp);
      $sp = str_replace("{idWorkflow}", $this->_idWorkflow, $sp);
      $sp = str_replace("{idUsuarioCreacion}", $this->_idUsuarioCreacion, $sp);
      $sp = str_replace("{idFlujoEstado}", $this->_idFlujoEstado, $sp);
      $sp = str_replace("{idCache}", $this->_idCache, $sp);
      $sp = str_replace("{esPadre}", $this->_esPadre, $sp);
      $sp = str_replace("{idFlujoPadre}", $this->_idFlujoPadre, $sp);
      $sp = str_replace("{eliminado}", $this->_eliminado, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
      $totalRegistros = count($arr);

      //si se encontraron registros entonces se asignan
      if ($totalRegistros > 0) {
        $row = $arr[0];
        $this->_id = $row["Id"];
        $this->_existe = 1;
      } else {
        $this->_id = -1;
        $this->_existe = 0;
      }
    } catch (Exception $e) {
      throw new Exception($e->getMessage());
    }
  }

  /**
   * elimina un registro
   * @author VSR, 07/12/2011
   */
  public function eliminar() {
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfFlujo_Eliminar({id});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{id}", $this->_id, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
      $totalRegistros = count($arr);

      //si se encontraron registros entonces se asignan
      $this->_id = -1;
      $this->_existe = 0;
    } catch (Exception $e) {
      throw new Exception($e->getMessage());
    }
  }

  /**
   * destructor
   * @author VSR, 07/12/2011
   */
  public function __destruct() {
    // destruye el objeto
  }
//</editor-fold>

//<editor-fold defaultstate="collapsed" desc="Metodos Compartidos">
  /**
   * crea los datos del flujo
   * @param <type> $idFlujo
   * @param <type> $idWorkflow
   * @param <type> $idEmpresa
   * @param <type> $idUsuario
   * @param <type> $idEstado
   * @param <type> $strNombre
   * @param <type> $replicarDatos
   * @param <type> $idFlujoPadre
   * @return string
   * @author VSR 08/12/2011
   */
  public static function grabarDatos($idFlujo, $idWorkflow, $idEmpresa, $idUsuario, $idEstado, $strNombre, $replicarDatos, $idFlujoPadre) {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfFlujo_GrabarDatos({idFlujo},{idWorkflow},{idEmpresa},{idUsuario},{idEstado},'{strNombre}',{replicarDatos},{idFlujoPadre});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idFlujo}", $idFlujo, $sp);
      $sp = str_replace("{idWorkflow}", $idWorkflow, $sp);
      $sp = str_replace("{idEmpresa}", $idEmpresa, $sp);
      $sp = str_replace("{idUsuario}", $idUsuario, $sp);
      $sp = str_replace("{idEstado}", $idEstado, $sp);
      $sp = str_replace("{strNombre}", $strNombre, $sp);
      $sp = str_replace("{replicarDatos}", $replicarDatos, $sp);
      $sp = str_replace("{idFlujoPadre}", $idFlujoPadre, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }

  /**
   *  Obtiene listado de flujos por aprobar
   * @param type $idEmpresa
   * @param type $idUsuario
   * @return string 
   */
  public static function obtenerPorAprobar($idEmpresa, $idUsuario, $nombreFlujo, $estado, $workflow) {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfFlujo_ObtenerPorAprobar({idEmpresa},{idUsuario},'{nombreFlujo}','{estado}','{workflow}');";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idEmpresa}", $idEmpresa, $sp);
      $sp = str_replace("{idUsuario}", $idUsuario, $sp);
      $sp = str_replace("{nombreFlujo}", $nombreFlujo, $sp);
      $sp = str_replace("{estado}", $estado, $sp);
      $sp = str_replace("{workflow}", $workflow, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp, Bd::MULTI_QUERY);
    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }

  /**
   * graba el historial por paso
   * @param <type> $strObservacion
   * @param <type> $idFlujo
   * @param <type> $idFlujoEstado
   * @param <type> $idPasoEstado
   * @param <type> $idPaso
   * @param <type> $idAprobador
   * @return <type> 
   */
  public static function grabarHistorial($strObservacion, $idFlujo, $idFlujoEstado, $idPasoEstado, $idPaso, $idAprobador) {
    $retorno = 0;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfFlujo_GrabarHistorial('{strObservacion}', {idFlujo}, {idFlujoEstado}, {idPasoEstado}, {idPaso}, {idAprobador});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{strObservacion}", $strObservacion, $sp);
      $sp = str_replace("{idFlujo}", $idFlujo, $sp);
      $sp = str_replace("{idFlujoEstado}", $idFlujoEstado, $sp);
      $sp = str_replace("{idPasoEstado}", $idPasoEstado, $sp);
      $sp = str_replace("{idPaso}", $idPaso, $sp);
      $sp = str_replace("{idAprobador}", $idAprobador, $sp);

      //ejecuta procedimiento
      $retorno = Bd::exec($sp, Bd::SCALAR);
    } catch (Exception $e) {
      $retorno = Sistema::CODIGO_SQL_ERROR;
    }
    return $retorno;
  }

  public static function cambiarEstadoAprobacion($idFlujo, $idWorkflow, $idEmpresa, $idPaso, $idEstadoPaso, $idUsuario, $observacion, $idCache) {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfFlujo_CambiarEstadoAprobacion({idFlujo}, {idWorkflow}, {idEmpresa}, {idPaso},{idEstadoPaso},{idUsuario},'{observacion}', {idCache});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idFlujo}", $idFlujo, $sp);
      $sp = str_replace("{idWorkflow}", $idWorkflow, $sp);
      $sp = str_replace("{idEmpresa}", $idEmpresa, $sp);
      $sp = str_replace("{idPaso}", $idPaso, $sp);
      $sp = str_replace("{idEstadoPaso}", $idEstadoPaso, $sp);
      $sp = str_replace("{idUsuario}", $idUsuario, $sp);
      $sp = str_replace("{observacion}", $observacion, $sp);
      $sp = str_replace("{idCache}", $idCache, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }

  /**
   * obtiene el historial de aprobaciones del flujo
   * @param <type> $idFlujo
   * @return string
   * @author VSR, 26/12/2011
   */
  public static function obtenerHistorialAprobaciones($idFlujo, $entidad)  {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfFlujo_ObtenerHistorialAprobaciones({idFlujo},'{entidad}');";
      //reemplaza marcas por valores reales
      $sp = str_replace("{idFlujo}", $idFlujo, $sp);
      $sp = str_replace("{entidad}", $entidad, $sp);
      //ejecuta procedimiento
      $arr = Bd::exec($sp);
    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }

    /**
   * obtiene el historial completo del flujo
   * @param <type> $idFlujo
   * @return string
   * @author VSR, 27/12/2011
   */
  public static function obtenerHistorialCompleto($idFlujo)  {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfFlujo_ObtenerHistorialCompleto({idFlujo});";
      //reemplaza marcas por valores reales
      $sp = str_replace("{idFlujo}", $idFlujo, $sp);
      //ejecuta procedimiento
      $arr = Bd::exec($sp);
    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }

  /**
   * obtiene el cache asociado
   * @param <type> $idWorkflow
   * @param <type> $idCache
   * @return string
   * @author VSR, 08/01/2012
   */
  public static function obtenerCache($idWorkflow, $idCache) {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfFlujo_ObtenerCache({idWorkflow}, {idCache});";
      //reemplaza marcas por valores reales
      $sp = str_replace("{idWorkflow}", $idWorkflow, $sp);
      $sp = str_replace("{idCache}", $idCache, $sp);
      //ejecuta procedimiento
      $arr = Bd::exec($sp, Bd::MULTI_QUERY);
    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }

  /**
   * obtiene los flujos historicos
   * @param <type> $idEmpresa
   * @param <type> $idUsuario
   * @return string
   */
  public static function obtenerHistoricos($idEmpresa, $idUsuario, $nombreFlujo, $fechaInicio, $fechaTermino, $estado, $workflow) {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfFlujo_ObtenerHistoricos({idEmpresa},{idUsuario},'{nombreFlujo}','{fechaInicio}','{fechaTermino}','{estado}','{workflow}');";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idEmpresa}", $idEmpresa, $sp);
      $sp = str_replace("{idUsuario}", $idUsuario, $sp);
      $sp = str_replace("{nombreFlujo}", $nombreFlujo, $sp);
      $sp = str_replace("{fechaInicio}", $fechaInicio, $sp);
      $sp = str_replace("{fechaTermino}", $fechaTermino, $sp);
      $sp = str_replace("{estado}", $estado, $sp);
      $sp = str_replace("{workflow}", $workflow, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }

  /**
   * obtiene los flujos activos
   * @param <type> $idEmpresa
   * @param <type> $idUsuario
   * @param <type> $nombreFlujo
   * @param <type> $fechaInicio
   * @param <type> $fechaTermino
   * @return string 
   * @author VSR, 24/05/2012
   */
  public static function obtenerActivos($idEmpresa, $idUsuario, $nombreFlujo, $fechaInicio, $fechaTermino,$workflow) {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfFlujo_ObtenerActivos({idEmpresa},{idUsuario},'{nombreFlujo}','{fechaInicio}','{fechaTermino}','{workflow}');";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idEmpresa}", $idEmpresa, $sp);
      $sp = str_replace("{idUsuario}", $idUsuario, $sp);
      $sp = str_replace("{nombreFlujo}", $nombreFlujo, $sp);
      $sp = str_replace("{fechaInicio}", $fechaInicio, $sp);
      $sp = str_replace("{fechaTermino}", $fechaTermino, $sp);
      $sp = str_replace("{workflow}", $workflow, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }

  /**
   * obtiene datos del creador del flujo
   * @param <type> $idFlujo
   * @return string
   * @author VSR, 01/02/2012
   */
  public static function obtenerDatosCreadorFlujo($idFlujo) {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfFlujo_ObtenerDatosCreadorFlujo({idFlujo});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idFlujo}", $idFlujo, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }

  /**
   * obtiene el ultimo id del historial del flujo
   * @param <type> $idFlujo
   * @return <type>
   * @author VSR, 03/02/2012
   */
  public static function obtenerUltimoIdHistorial($idFlujo) {
    $retorno = 0;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfFlujo_ObtenerUltimoIdHistorial({idFlujo});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idFlujo}", $idFlujo, $sp);

      //ejecuta procedimiento
      $retorno = Bd::exec($sp, Bd::SCALAR);
    } catch (Exception $e) {
      $retorno = Sistema::CODIGO_SQL_ERROR;
    }
    return $retorno;
  }

  /**
   * elimina el flujo logicamente
   * @param <type> $idFlujo
   * @param <type> $idUsuario
   * @return <type>
   * @author VSR, 04/02/2012
   */
  public static function eliminacionLogica($idFlujo, $idUsuario) {
    $retorno = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfFlujo_EliminacionLogica({idFlujo},{idUsuario});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idFlujo}", $idFlujo, $sp);
      $sp = str_replace("{idUsuario}", $idUsuario, $sp);

      //ejecuta procedimiento
      $retorno = Bd::exec($sp, Bd::SCALAR);
    } catch (Exception $e) {
      $retorno = Sistema::CODIGO_SQL_ERROR;
    }
    return $retorno;
  }



//</editor-fold>
}
?>

